// Package config 提供配置服务的HTTP处理器
//
// API 接口说明：
// 1. 获取完整配置
//   - 路径：POST /api/v1/configs/get
//   - 请求：空
//   - 响应：
//     {
//     "code": 0,
//     "message": "success",
//     "data": {
//     "key1": value1,
//     "key2": value2
//     }
//     }
//
// 2. 更新完整配置
//   - 路径：POST /api/v1/configs/update/all
//   - 请求：
//     {
//     "key1": value1,
//     "key2": value2
//     }
//   - 响应：
//     {
//     "code": 0,
//     "message": "success"
//     }
//
// 3. 更新单条配置
//   - 路径：POST /api/v1/configs/update
//   - 请求：
//     {
//     "key": "mqtt.broker_address",
//     "value": "mqtt://server:1883"
//     }
//   - 响应：
//     {
//     "code": 0,
//     "message": "success"
//     }
//
// 响应说明：
// 1. 状态码
//   - code = 0：操作成功
//   - code != 0：操作失败
//
// 2. 错误处理
//   - HTTP 状态码表示请求状态
//   - code 字段表示业务状态
//   - message 字段提供错误详情
//
// 3. 数据格式
//   - 所有请求和响应均使用 JSON 格式
//   - Content-Type: application/json
//   - 支持所有 JSON 数据类型
//
// 4. 安全性
//   - 建议在内网使用
//   - 可按需添加认证机制
//   - 注意防止配置信息泄露
package config

import (
	"net/http"
	"time"

	"gitee.com/rw555/fdsmastergo/pkg/logger"
	"github.com/gin-gonic/gin"
	"go.uber.org/zap"
)

// Handler 配置服务的HTTP处理器
type Handler struct {
	storage ConfigStorage // 配置服务实例
}

// NewHandler 创建新的HTTP处理器
func NewHandler(storage ConfigStorage) *Handler {
	return &Handler{storage: storage}
}

// GetConfig 获取完整的系统配置
func (h *Handler) GetConfig(c *gin.Context) {
	config, err := h.storage.GetAllConfigs()
	if err != nil {
		logger.SystemError("获取系统配置失败",
			zap.Error(err))
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"data":    config,
		"message": "获取成功",
	})
}

// UpdateAllConfig 更新完整的系统配置
func (h *Handler) UpdateAllConfig(c *gin.Context) {
	var config map[string]interface{}
	if err := c.BindJSON(&config); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "无效的请求数据"})
		return
	}

	// 打印更新前的配置
	logger.SystemInfo("更新前的系统配置", zap.Any("config", config))

	if err := h.storage.UpdateAllConfigs(config); err != nil {
		logger.SystemError("更新系统配置失败",
			zap.Error(err))
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": "更新成功"})
}

// UpdateConfig 更新单条配置
func (h *Handler) UpdateConfig(c *gin.Context) {
	var config map[string]interface{}
	if err := c.BindJSON(&config); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "无效的请求数据"})
		return
	}

	if err := h.storage.UpdateConfigItem(config["key"].(string), config["value"]); err != nil {
		logger.SystemError("更新系统配置失败",
			zap.Error(err))
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": "更新成功"})
}

// UpdateConfigItem 更新单个配置项
func (h *Handler) UpdateConfigItem(c *gin.Context) {
	var config map[string]interface{}
	if err := c.BindJSON(&config); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "无效的请求数据"})
		return
	}

	if err := h.storage.UpdateConfigItem(config["key"].(string), config["value"]); err != nil {
		logger.SystemError("更新系统配置失败",
			zap.Error(err))
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": "更新成功"})
}

// HandleGetAutoModeSessions 获取自动模式运行记录
func (h *Handler) HandleGetAutoModeSessions(c *gin.Context) {
	// 解析请求参数
	var req struct {
		StartDate string `json:"start_date"`
		EndDate   string `json:"end_date"`
		Limit     int    `json:"limit"`
		Offset    int    `json:"offset"`
	}

	if err := c.BindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "无效的请求数据"})
		return
	}

	// 设置默认值
	if req.StartDate == "" {
		req.StartDate = time.Now().AddDate(0, -1, 0).Format("2006-01-02")
	}
	if req.EndDate == "" {
		req.EndDate = time.Now().Format("2006-01-02")
	}
	if req.Limit <= 0 {
		req.Limit = 10
	}
	if req.Offset < 0 {
		req.Offset = 0
	}

	// 解析日期
	startDate, err := time.Parse("2006-01-02", req.StartDate)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "无效的开始日期格式，请使用YYYY-MM-DD格式"})
		return
	}

	// 设置结束日期为当天的23:59:59
	endDate, err := time.Parse("2006-01-02", req.EndDate)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "无效的结束日期格式，请使用YYYY-MM-DD格式"})
		return
	}
	endDate = endDate.Add(24*time.Hour - time.Second) // 设置为当天的23:59:59

	// 查询数据库获取会话记录
	sessions, err := h.storage.GetAutoModeSessions(startDate, endDate)
	if err != nil {
		logger.SystemError("获取自动模式会话记录失败", zap.Error(err))
		c.JSON(http.StatusInternalServerError, gin.H{"error": "获取自动模式会话记录失败"})
		return
	}

	// 获取当前总运行时长
	totalMinutes, err := h.storage.GetAutoModeTotalTime()
	if err != nil {
		logger.SystemError("获取自动模式总运行时长失败", zap.Error(err))
		c.JSON(http.StatusInternalServerError, gin.H{"error": "获取自动模式总运行时长失败"})
		return
	}

	// 计算当前区间的总时长（分钟）
	var currentTotalMinutes int
	for _, session := range sessions {
		// 计算每个会话的时长（分钟）
		duration := session.EndTime.Sub(session.StartTime)
		minutes := int(duration.Minutes())
		currentTotalMinutes += minutes
	}

	// 应用分页
	var paginatedSessions []AutoModeSession
	if req.Offset < len(sessions) {
		end := req.Offset + req.Limit
		if end > len(sessions) {
			end = len(sessions)
		}
		paginatedSessions = sessions[req.Offset:end]
	}

	// 返回结果
	c.JSON(http.StatusOK, gin.H{
		"code":                  0,
		"message":               "获取自动模式会话记录成功",
		"data":                  paginatedSessions,
		"total_sessions":        len(sessions),
		"current_total_minutes": currentTotalMinutes,
		"total_minutes":         totalMinutes,
		"start_date":            req.StartDate,
		"end_date":              req.EndDate,
	})
}

// HandleSaveAutoModeSession 保存自动模式运行记录
func (h *Handler) HandleSaveAutoModeSession(c *gin.Context) {
	var req struct {
		StartTime string `json:"start_time" binding:"required"`
		EndTime   string `json:"end_time" binding:"required"`
	}

	if err := c.BindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "无效的请求数据"})
		return
	}

	// 解析时间
	startTime, err := time.Parse("2006-01-02 15:04:05", req.StartTime)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "无效的开始时间格式，请使用YYYY-MM-DD HH:MM:SS格式"})
		return
	}

	endTime, err := time.Parse("2006-01-02 15:04:05", req.EndTime)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "无效的结束时间格式，请使用YYYY-MM-DD HH:MM:SS格式"})
		return
	}

	// 保存记录
	err = h.storage.SaveAutoModeSession(startTime, endTime)
	if err != nil {
		logger.SystemError("保存自动模式运行记录失败", zap.Error(err))
		c.JSON(http.StatusInternalServerError, gin.H{"error": "保存自动模式运行记录失败"})
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": "自动模式运行记录保存成功"})
}
